// 通用工具函数
/**
 * 暂停指定时间（单位：毫秒）
 * @param {Number} millisecond
 */
export function sleep(millisecond) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve()
    }, millisecond)
  })
}

/**
 * 循环调用，直到传入的方法执行成功
 * @param {Function} func 无参方法，执行成功后的返回值为true
 */
export async function ensureExecuteSuccess(func) {
  if (typeof func !== 'function') {
    console.warn('argument expectation  is a function')
    return
  }
  let isSuccess = func()
  if (!isSuccess) {
    for (let i = 0; i < 10; ++i) {
      await sleep(i * 100)
      isSuccess = func()
      if (isSuccess) {
        break
      }
    }
  }
}

/**
 * 同步管理
 */
export class SyncManager {
  /**
   * @param {Number} waitInterval 等待的间隔时间（单位：毫秒）
   */
  constructor(waitInterval) {
    this.isLocked = false // 是否已锁定
    this.waitInterval = waitInterval || 1
  }
  /**
   * 执行传入的方法
   * @param {Function} func
   */
  async execute(func) {
    if (typeof func !== 'function') {
      return
    }
    if (this.isLocked) {
      await sleep(this.waitInterval)
      await this.execute(func)
      return
    } else {
      this.isLocked = true
      try {
        await func()
      } finally {
        this.isLocked = false
      }
    }
  }
}

export class Once {
  constructor(ctx) {
    this.lastTriggeredAt = 0
    this.ctx = ctx
  }
  excute(func, args = [], wait = 500) {
    const currentThis = this
    this.lastTriggeredAt = new Date().getTime()
    setTimeout(() => {
      const now = new Date().getTime()
      if ((now - wait) >= currentThis.lastTriggeredAt) {
        // console.log('回调执行once', func, currentThis.ctx)
        func.call(currentThis.ctx, ...args)
      }
    }, wait)
  }
}

/**
 * 自增长的数值
 */
export class AutoIncrementNum {
  /**
   * @param {Number} initNum 初始值
   */
  constructor(initNum) {
    this.num = initNum || 1
  }
  /**
   * 获取下一个数值
   */
  getNextNum() {
    return this.num++
  }
}
